home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / misc / emu / ATUtilities.lha / ATUtilities / atf.c < prev    next >
C/C++ Source or Header  |  2000-09-26  |  50KB  |  2,206 lines
  1. /* ******************************************************************* */
  2. /* **                                                               ** */
  3. /* **                      ATUtilities Library                      ** */
  4. /* **            Copright (C) 1992-1994 by Thomas Dreibholz         ** */
  5. /* **                      All rights reserved                      ** */
  6. /* **                                                               ** */
  7. /* **                          Funktionen                           ** */
  8. /* **                                                               ** */
  9. /* ******************************************************************* */
  10.  
  11. #include "janus.h"
  12. #include "ATUtilities.h"
  13.  
  14. #define VERSION "ATUtilities Library - Version 4.0"
  15.  
  16. extern struct Library       *IconBase;
  17. extern struct Library       *SysBase;
  18. extern struct DosLibrary    *DOSBase;
  19. extern struct IntuitionBase *IntuitionBase;
  20. extern struct GfxBase       *GfxBase;
  21. extern struct JanusBase     *JanusBase;
  22. extern struct Library       *WorkbenchBase;
  23. extern struct DiskfontBase  *DiskfontBase;
  24. extern struct TextFont      *OpalFont;
  25.  
  26. struct Remember             *Remember;
  27. struct ATUtilities          *atu;
  28.  
  29. VOID   ErrorRequest();
  30. VOID   UseMenuStrip();
  31. VOID   LibraryInfo();
  32. VOID   FreeCommMemory();
  33. VOID   DrawIt();
  34. VOID   PrintText();
  35. VOID   SelectStdFPen();
  36. VOID   SelectStdBPen();
  37. VOID   InfoText();
  38. VOID   Utility();
  39. VOID   InformationBox();
  40. VOID   DrawMPTextBorder();
  41. VOID   MacFormat();
  42. VOID   RemoveMenuStrip();
  43. UBYTE *GetOpalLine();
  44. BOOL   MultiRequest();
  45. UBYTE *AllocCommMemory();
  46. UWORD  BorderHeight();
  47.  
  48. struct MenuItem  *AddItem();
  49. struct Menu      *AddMenu();
  50. struct MenuStrip *BuildMenuStrip();
  51.  
  52.  
  53. struct CommManager
  54. {
  55.  LONG   UserCount;
  56.  UBYTE *CommMemory;
  57. };
  58. struct CommManager CommManager={0L,NULL};
  59.  
  60.  
  61. struct TextAttr OpalAttr=
  62. {
  63.  "opal.font",9,
  64.  FS_NORMAL,0
  65. };
  66.  
  67. struct TextAttr TopazAttr=
  68. {
  69.  "topaz.font",8,
  70.  FS_NORMAL,FPF_ROMFONT
  71. };
  72.  
  73. struct IntuiText Warn_Text[]=
  74. {
  75.  {2,0,JAM1,10,9,&OpalAttr,"Warnung: Das Beenden dieses ATUtilities",&Warn_Text[1]},
  76.  {2,0,JAM1,10,18,&OpalAttr,"kann Probleme verursachen, wenn MS-DOS",&Warn_Text[2]},
  77.  {2,0,JAM1,10,27,&OpalAttr,"einen erneuten Zugriffsversuch macht!",&Warn_Text[3]},
  78.  {2,0,JAM1,10,36,&OpalAttr,"Nach Beendigung sollte ein Reset der",&Warn_Text[4]},
  79.  {2,0,JAM1,10,45,&OpalAttr,"PC/AT-Karte gemacht werden.",&Warn_Text[5]},
  80.  {2,0,JAM1,10,54,&OpalAttr,"Wollen Sie wirklich beenden?",NULL}
  81. };
  82.  
  83. struct IntuiText Beende_Text=
  84. {
  85.  2,0,JAM1,10,8,&OpalAttr,"Ja, Programmende",NULL
  86. };
  87.  
  88. struct IntuiText BeendeNicht_Text=
  89. {
  90.  2,0,JAM1,10,8,&OpalAttr,"Nein, zurück",NULL
  91. };
  92.  
  93. struct IntuiText Okay_Text=
  94. {
  95.  2,0,JAM1,10,8,&OpalAttr,"Okay",NULL
  96. };
  97.  
  98. UBYTE *Fehler[]=
  99. {
  100.  {"Fehler beim Öffnen der Janus-Library."},
  101.  {"Fehler beim Öffnen der DiskFont-Library."},
  102.  {"Fehler beim Laden des Opal/9-Fonts."},
  103.  {"Fehler bei der Menü-Installation."},
  104.  {"Nicht genug freier Speicher."},
  105.  {"Nicht genug freie Task-Signale."},
  106.  {"Janus-Interrupt ist schon belegt!"},
  107.  {"Nicht genug freier DualPorted-Speicher."},
  108.  {"Kann Message-Port nicht erstellen."},
  109.  {"Kann Port für Utility-Manager nicht erstellen."},
  110.  {"Kann Service nicht erstellen."},
  111.  {"ATUtilities: Undefinierter Fehler."}
  112. };
  113.  
  114. struct MenuItem StdItem=
  115. {
  116.  NULL,
  117.  140,0,300,10,
  118.  HIGHCOMP|ITEMTEXT|ITEMENABLED,0L,
  119.  NULL,NULL,0,NULL,0
  120. };
  121.  
  122. struct IntuiText StdReqText=
  123.  {
  124.   2,0,JAM1,10,8,&OpalAttr,NULL,NULL
  125.  };
  126.  
  127. struct IntuiText StdText=
  128. {
  129.  AUTOFRONTPEN,AUTOBACKPEN,AUTODRAWMODE,AUTOLEFTEDGE,
  130.  1,&OpalAttr,NULL,NULL
  131. };
  132.  
  133. struct NewWindow StdWindow=
  134. {
  135.  0,0,0,0,
  136.  0,1,
  137.  0L,0L,
  138.  NULL,NULL,NULL,NULL,NULL,
  139.  50,20,640,256,
  140.  WBENCHSCREEN
  141. };
  142.  
  143. struct Gadget StdGadget=
  144. {
  145.  NULL,
  146.  0,0,0,0,
  147.  GADGHCOMP,
  148.  RELVERIFY|GADGIMMEDIATE,
  149.  BOOLGADGET,
  150.  NULL,NULL,NULL,0L,
  151.  NULL,0,NULL
  152. };
  153.  
  154. struct Gadget StdStrGadget=
  155. {
  156.  NULL,
  157.  0,0,0,0,
  158.  GADGHCOMP,
  159.  RELVERIFY|GADGIMMEDIATE|TOGGLESELECT,
  160.  STRGADGET,
  161.  NULL,NULL,NULL,0L,
  162.  NULL,0,NULL
  163. };
  164.  
  165.  
  166. /* Opal-Font öffnen */
  167. struct TextFont *GetOpalFont()
  168. {
  169.  return(OpalFont);
  170. }
  171.  
  172.  
  173. /* Warnung vorm Beenden von externen ATUtilities */
  174. BOOL ExitWarning()
  175. {
  176.  return(AutoRequest(NULL,&Warn_Text[0],&Beende_Text,&BeendeNicht_Text,
  177.                     VANILLAKEY,0,450,88));
  178. }
  179.  
  180.  
  181. /* Abfrage zur Übernahme von Einstellungen */
  182. BOOL UsePrefs()
  183. {
  184.  return(MultiRequest("Wollen Sie die gemachten Einstellungen",
  185.                      "übernehmen oder verwerfen ?",
  186.                      "Übernehmen","Verwerfen"));
  187. }
  188.  
  189.  
  190. /* Fehler-Requester */
  191. VOID ErrorRequest(num)
  192.  ULONG num;
  193. {
  194.  struct IntuiText Text;
  195.  
  196.  CopyMem(&StdReqText,&Text,sizeof(struct IntuiText));
  197.  if(num>ERRORCNT) num=ERRORCNT;
  198.  Text.IText=Fehler[num];
  199.  AutoRequest(NULL,&Text,&Okay_Text,&Okay_Text,VANILLAKEY,0,400,35);
  200. }
  201.  
  202.  
  203. /* Info-Requester */
  204. VOID InfoRequest(info)
  205.  UBYTE *info;
  206. {
  207.  struct IntuiText Text;
  208.  
  209.  CopyMem(&StdReqText,&Text,sizeof(struct IntuiText));
  210.  Text.IText=info;
  211.  AutoRequest(NULL,&Text,&Okay_Text,&Okay_Text,VANILLAKEY,0,400,35);
  212. }
  213.  
  214.  
  215. /* Multi-Requester */
  216. BOOL MultiRequest(t1,t2,p,n)
  217.  UBYTE *t1,*t2,*p,*n;
  218. {
  219.  struct IntuiText Text1,Text2,TextP,TextN;
  220.  
  221.  CopyMem(&StdReqText,&Text1,sizeof(struct IntuiText));
  222.  CopyMem(&StdReqText,&Text2,sizeof(struct IntuiText));
  223.  CopyMem(&StdReqText,&TextP,sizeof(struct IntuiText));
  224.  CopyMem(&StdReqText,&TextN,sizeof(struct IntuiText));
  225.  if(n==NULL) n=p;
  226.  Text1.IText=t1;
  227.  Text1.NextText=&Text2;
  228.  Text2.IText=t2;
  229.  Text2.TopEdge=18;
  230.  TextP.IText=p;
  231.  TextN.IText=n;
  232.  return(AutoRequest(NULL,&Text1,&TextP,&TextN,VANILLAKEY,0,450,45));
  233. }
  234.  
  235.  
  236. VOID CallUtility(name)
  237.  UBYTE *name;
  238. {
  239.  Utility(name,UTILITY_CALL);
  240. }
  241.  
  242. /* Utility-Fenster aufrufen */
  243. VOID Utility(name,type)
  244.  UBYTE *name;
  245.  UWORD  type;
  246. {
  247.  register struct MsgPort *port;
  248.  register struct Message *msg;
  249.  
  250.  port=FindPort(name);
  251.  if(port!=NULL)
  252.   {
  253.    msg=AllocMem(sizeof(struct Message),MEMF_CLEAR|MEMF_PUBLIC);
  254.    if(msg!=NULL)
  255.     {
  256.      msg->mn_Node.ln_Type=NT_MESSAGE;
  257.      msg->mn_Node.ln_Name=type;
  258.      msg->mn_Node.mn_Length=sizeof(struct Message);
  259.      PutMsg(port,msg);
  260.     }
  261.    else
  262.     {
  263.      ErrorRequest(ERROR_ALLOC);
  264.     }
  265.   }
  266.  else
  267.   {
  268.    MultiRequest("Externe Erweiterung ist (noch) nicht aktiv:",name,"Okay",NULL);
  269.   }
  270. }
  271.  
  272.  
  273. /* Utilityliste laden */
  274. struct MenuItem *CreateUtilityList()
  275. {
  276.  REGISTER BOOL                err;
  277.  REGISTER WORD                i,y;
  278.  register struct FileHandle  *fh;
  279.  register struct MenuItem    *item,*oldItem;
  280.  register struct IntuiText   *text;
  281.  
  282.  err=FALSE;
  283.  item=oldItem=NULL;
  284.  Remember=NULL;
  285.  atu=AllocRemember(Remember,sizeof(struct ATUtilities),MEMF_CLEAR|MEMF_PUBLIC);
  286.  if(atu!=NULL)
  287.   {
  288.    fh=Open("AT:Prefs/UtilityManager.prefs",MODE_OLDFILE);
  289.    if(fh!=NULL)
  290.     {
  291.      Read(fh,atu,sizeof(struct ATUtilities));
  292.      Close(fh);
  293.      y=4;
  294.      for(i=0;i<=atu->Count;i++)
  295.       {
  296.        oldItem=item;
  297.        item=AllocRemember(Remember,sizeof(struct MenuItem),MEMF_CLEAR|MEMF_PUBLIC);
  298.        text=AllocRemember(Remember,sizeof(struct IntuiText),MEMF_CLEAR|MEMF_PUBLIC);
  299.        if((item==NULL)||(text==NULL))
  300.         {
  301.          FreeRemember(Remember,TRUE);
  302.          return(NULL);
  303.         }
  304.        CopyMem(&StdItem,item,sizeof(struct MenuItem));
  305.        CopyMem(&StdText,text,sizeof(struct IntuiText));
  306.        item->NextItem=oldItem;
  307.        item->TopEdge=y;
  308.        item->ItemFill=text;
  309.        text->IText=&atu->ATUtility[i].Name;
  310.        y+=10;
  311.       }
  312.     }
  313.    else
  314.     {
  315.      FreeRemember(Remember,TRUE);
  316.      MultiRequest("Datei AT:Prefs/ATUtilityManager.prefs",
  317.                   "konnte nicht geöffnet werden.","Okay",NULL);
  318.     }
  319.   }
  320.  return(item);
  321. }
  322.  
  323.  
  324. /* Utility-Liste entfernen */
  325. VOID DeleteUtilityList()
  326. {
  327.  if(Remember)
  328.   {
  329.    FreeRemember(Remember,TRUE);
  330.    Remember=NULL;
  331.   }
  332. }
  333.  
  334.  
  335. /* Utility aus Liste aufrufen */
  336. VOID CallUtilityList(num)
  337.  ULONG num;
  338. {
  339.  if(num<=atu->Count)
  340.   {
  341.    num=atu->Count-num;
  342.    if(num<atu->Count)
  343.     {
  344.      CallUtility(&atu->ATUtility[num].PortName);
  345.     }
  346.    else if(num==atu->Count) LibraryInfo();
  347.   }
  348. }
  349.  
  350.  
  351. /* JInterrupt-Handler erstellen */
  352. struct ExtSetupSig *CreatePublicHandler(jint)
  353.  UBYTE jint;
  354. {
  355.  REGISTER LONG                JanusSignal;
  356.  REGISTER UBYTE              *mem;
  357.  register struct ExtSetupSig *ess;
  358.  register struct SetupSig    *ss;
  359.  
  360.  ess=NULL;
  361.  Forbid();
  362.  if(JanusBase==NULL) JanusBase=OpenLibrary("janus.library",0L);
  363.  Permit();
  364.  if(JanusBase!=NULL)
  365.   {
  366.    JanusSignal=AllocSignal(-1L);
  367.    if(JanusSignal>=0)
  368.     {
  369.      mem=AllocCommMemory();
  370.      if(mem!=NULL)
  371.       {
  372.        ess=AllocMem(sizeof(struct ExtSetupSig),MEMF_CLEAR|MEMF_PUBLIC);
  373.        if(ess!=NULL)
  374.         {
  375.          ss=SetupJanusSig(jint,JanusSignal,0L,0L);
  376.          if(ss!=NULL)
  377.           {
  378.            ess->SetupSig=ss;
  379.            ess->ByteAccess=MakeBytePtr(mem);
  380.            ess->WordAccess=MakeWordPtr(mem);
  381.            ess->Offset=JanusMemToOffset(mem);
  382.            ess->JanusSignal=JanusSignal;
  383.            ess->JanusSignalMask=(1L<<JanusSignal);
  384.            SetParamOffset(jint,ess->Offset);
  385.           }
  386.          else
  387.           {
  388.            FreeMem(ess,sizeof(struct ExtSetupSig));
  389.            ess=NULL;
  390.            FreeSignal(JanusSignal);
  391.            FreeCommMemory();
  392.            ErrorRequest(ERROR_SETUP);
  393.           }
  394.         }
  395.        else
  396.         {
  397.          FreeSignal(JanusSignal);
  398.          FreeCommMemory();
  399.          ErrorRequest(ERROR_SETUP);
  400.         }
  401.       }
  402.      else
  403.       {
  404.        FreeSignal(JanusSignal);
  405.        ErrorRequest(ERROR_JALLOC);
  406.       }
  407.     }
  408.    else
  409.     {
  410.      ErrorRequest(ERROR_SIGNAL);
  411.     }
  412.   }
  413.  else
  414.   {
  415.    ErrorRequest(ERROR_JANUS);
  416.   }
  417.  return(ess);
  418. }
  419.  
  420.  
  421. /* JInterrupt-Handler löschen */
  422. VOID DeletePublicHandler(ess)
  423.  struct ExtSetupSig *ess;
  424. {
  425.  register struct SetupSig *ss;
  426.  
  427.  ss=ess->SetupSig;
  428.  SetParamOffset(ss->ss_JanusIntNum,-1);
  429.  CleanupJanusSig(ss);
  430.  FreeSignal(ess->JanusSignal);
  431.  FreeCommMemory();
  432.  FreeMem(ess,sizeof(struct ExtSetupSig));
  433. }
  434.  
  435.  
  436. /* Kommunikationsspeicher belegen */
  437. UBYTE *AllocCommMemory()
  438. {
  439.  REGISTER UBYTE *mem;
  440.  
  441.  Forbid();
  442.  if(CommManager.CommMemory!=NULL)
  443.   {
  444.    mem=CommManager.CommMemory;
  445.    CommManager.UserCount++;
  446.   }
  447.  else
  448.   {
  449.    mem=AllocJanusMem(sizeof(struct CommMemory),MEMF_BUFFER|MEM_WORDACCESS);
  450.    if(mem!=NULL)
  451.     {
  452.      CommManager.CommMemory=mem;
  453.      CommManager.UserCount=1;
  454.     }
  455.   }
  456.  Permit();
  457.  return(mem);
  458. }
  459.  
  460.  
  461. /* Kommunikationsspeicher freigeben */
  462. VOID FreeCommMemory()
  463. {
  464.  
  465.  Forbid();
  466.  CommManager.UserCount--;
  467.  if(CommManager.UserCount==0)
  468.   {
  469.    FreeJanusMem(CommManager.CommMemory,sizeof(struct CommMemory));
  470.    CommManager.CommMemory=NULL;
  471.   }
  472.  Permit();
  473. }
  474.  
  475.  
  476. /* Gadget-Rahmen zeichnen (normal) */
  477. VOID DrawPBorder(win,x,y,w,h,test)
  478.  struct Window *win;
  479.  UWORD          x,y,w,h,test;
  480. {
  481.  REGISTER BYTE             f,b;
  482.  register struct RastPort *rp;
  483.  
  484.  rp=win->RPort;
  485.  if(SysBase->lib_Version>=36) { f=2; b=1; } else { f=1; b=2; }
  486.  DrawIt(rp,x,y,w,h,f,b,test);
  487. }
  488.  
  489.  
  490. /* Gadget-Rahmen zeichnen (gedrückt) */
  491. VOID DrawNBorder(win,x,y,w,h,test)
  492.  struct Window *win;
  493.  UWORD          x,y,w,h,test;
  494. {
  495.  REGISTER BYTE             f,b;
  496.  register struct RastPort *rp;
  497.  
  498.  rp=win->RPort;
  499.  if(SysBase->lib_Version>=36) { f=1; b=2; } else { f=2; b=1; }
  500.  DrawIt(rp,x,y,w,h,f,b,test);
  501. }
  502.  
  503.  
  504. /* Gadget-Rahmen mit Text zeichnen (normal) */
  505. VOID DrawPTextBorder(win,x,y,w,h,text,test)
  506.  struct Window *win;
  507.  UWORD          x,y,w,h;
  508.  UBYTE         *text;
  509.  UWORD          test;
  510. {
  511.  REGISTER BYTE             f,b;
  512.  register struct RastPort *rp;
  513.  
  514.  rp=win->RPort;
  515.  if(SysBase->lib_Version>=36) { f=2; b=1; } else { f=1; b=2; }
  516.  DrawIt(rp,x,y,w,h,f,b,test);
  517.  SelectStdFPen(rp);
  518.  PrintText(rp,x,y,w,text);
  519. }
  520.  
  521.  
  522. /* Gadget-Rahmen mit Text zeichnen (gedrückt) */
  523. VOID DrawNTextBorder(win,x,y,w,h,text,test)
  524.  struct Window *win;
  525.  UWORD          x,y,w,h;
  526.  UBYTE         *text;
  527.  UWORD          test;
  528. {
  529.  REGISTER BYTE             f,b;
  530.  register struct RastPort *rp;
  531.  
  532.  rp=win->RPort;
  533.  if(SysBase->lib_Version>=36) { f=1; b=2; } else { f=2; b=1; }
  534.  DrawIt(rp,x,y,w,h,f,b,test);
  535.  SelectStdFPen(rp);
  536.  PrintText(rp,x,y,w,text);
  537. }
  538.  
  539.  
  540. /* Gadget-Rahmen zeichnen (intern) */
  541. VOID DrawIt(rp,x,y,w,h,f,b,fill)
  542.  struct RastPort *rp;
  543.  UWORD            x,y,w,h;
  544.  UBYTE            f,b;
  545.  UWORD            fill;
  546. {
  547.  
  548.  if(fill==1)
  549.   {
  550.    SetAPen(rp,0);
  551.    RectFill(rp,x+1,y+2,x+w-2,y+h-2);
  552.   }
  553.  SetAPen(rp,f);
  554.  Move(rp,x,y+h);
  555.  Draw(rp,x,y);
  556.  Draw(rp,x+w,y);
  557.  
  558.  SetAPen(rp,b);
  559.  Move(rp,x+1,y+h);
  560.  Draw(rp,x+w,y+h);
  561.  Draw(rp,x+w,y+1);
  562. }
  563.  
  564.  
  565. /* Gadget-Text zentrieren und ausgeben (intern) */
  566. VOID PrintText(rp,x,y,w,text)
  567.  struct RastPort *rp;
  568.  UWORD            x,y,w;
  569.  UBYTE           *text;
  570. {
  571.  REGISTER WORD i,l;
  572.  
  573.  l=TextLength(rp,text,strlen(text));
  574.  i=(w-l)/2;
  575.  Move(rp,x+i,y+9);
  576.  Text(rp,text,strlen(text));
  577. }
  578.  
  579.  
  580. /* Text ausgeben */
  581. VOID WriteText(rp,x,y,text)
  582.  struct RastPort *rp;
  583.  UWORD            x,y;
  584.  UBYTE           *text;
  585. {
  586.  
  587.  Move(rp,x,y);
  588.  Text(rp,text,strlen(text));
  589. }
  590.  
  591.  
  592. /* Text ausgeben und falls nötig entsprechend kürzen*/
  593. VOID WriteMText(rp,x,y,width,text)
  594.  struct RastPort *rp;
  595.  UWORD            x,y;
  596.  UWORD            width;
  597.  UBYTE           *text;
  598. {
  599.  REGISTER UWORD i,j;
  600.  UBYTE          s[204];
  601.  
  602.  width-=20;
  603.  i=strlen(text);
  604.  j=TextLength(rp,text,i);
  605.  if(j>=width)
  606.   {
  607.    if(i>198) { i=198; s[199]=0x00; }
  608.    strncpy(&s,text,i);
  609.    MacFormat(rp,&s,width);
  610.    Move(rp,x,y);
  611.    Text(rp,&s,strlen(&s));
  612.   } else WriteText(rp,x,y,text);
  613. }
  614.  
  615.  
  616. /* Standard-Vordergrundfarbe */
  617. VOID SelectStdFPen(rp)
  618.  struct RastPort *rp;
  619. {
  620.  REGISTER UBYTE f;
  621.  
  622.  if(SysBase->lib_Version>=36) f=2; else f=1;
  623.  SetAPen(rp,f);
  624. }
  625.  
  626.  
  627. /* Standard-Hintergrundfarbe */
  628. VOID SelectStdBPen(rp)
  629.  struct RastPort *rp;
  630. {
  631.  REGISTER UBYTE b;
  632.  
  633.  if(SysBase->lib_Version>=36) b=1; else b=2;
  634.  SetAPen(rp,b);
  635. }
  636.  
  637.  
  638. /* Fenster öffnen */
  639. struct Window *CreateWindow(scr,title,x,y,w,h,idcmp,flags)
  640.  struct Screen *scr;
  641.  UBYTE         *title;
  642.  UWORD          x,y,w,h;
  643.  ULONG          flags,idcmp;
  644. {
  645.  struct NewWindow *nw;
  646.  struct Window    *win;
  647.  
  648.  nw=AllocMem(sizeof(struct NewWindow),MEMF_CLEAR|MEMF_PUBLIC);
  649.  if(nw!=NULL)
  650.   {
  651.    CopyMem(&StdWindow,nw,sizeof(struct NewWindow));
  652.    nw->LeftEdge=x;
  653.    nw->TopEdge=y;
  654.    nw->Width=w;
  655.    nw->Height=h;
  656.    nw->IDCMPFlags=idcmp;
  657.    nw->Flags=flags;
  658.    nw->Title=title;
  659.    if(scr!=NULL)
  660.     {
  661.      nw->Screen=scr;
  662.      nw->Type=CUSTOMSCREEN;
  663.      nw->MaxWidth=scr->Width;
  664.      nw->MaxHeight=scr->Height;
  665.     }
  666.    win=OpenWindow(nw);
  667.    if(win!=NULL) win->UserData=NULL;
  668.    FreeMem(nw,sizeof(struct NewWindow));
  669.    return(win);
  670.   }
  671.  return(NULL);
  672. }
  673.  
  674.  
  675. /* Screen öffnen */
  676. struct Screen *CreateScreen(title,w,h,d,vmodes)
  677.  UBYTE         *title;
  678.  UWORD          w,h;
  679.  UBYTE          d;
  680.  ULONG          vmodes;
  681. {
  682.  struct NewScreen *ns;
  683.  struct Screen    *scr;
  684.  
  685.  ns=AllocMem(sizeof(struct NewScreen),MEMF_CLEAR|MEMF_PUBLIC);
  686.  if(ns!=NULL)
  687.   {
  688.    ns->Width=w;
  689.    ns->Height=h;
  690.    ns->Depth=d;
  691.    ns->Type=CUSTOMSCREEN;
  692.    ns->DefaultTitle=title;
  693.    ns->ViewModes=vmodes;
  694.    ns->BlockPen=1;
  695.    ns->Font=&TopazAttr;
  696.    scr=OpenScreen(ns);
  697.    FreeMem(ns,sizeof(struct NewScreen));
  698.    return(scr);
  699.   }
  700.  return(NULL);
  701. }
  702.  
  703.  
  704. /* Fenster entfernen */
  705. VOID DeleteStdWindow(win)
  706.  struct Window *win;
  707. {
  708.  REGISTER BOOL             bool;
  709.  register struct Remember *rem;
  710.  
  711.  bool=FALSE;
  712.  if(win->UserData)
  713.   {
  714.    rem=&win->UserData;
  715.    bool=TRUE;
  716.   }
  717.  CloseWindow(win);
  718.  if(bool) FreeRemember(rem,TRUE);
  719. }
  720.  
  721.  
  722. /* Bool- oder Toggle-Gadget erstellen */
  723. struct Gadget *CreateBoolToggleGadget(test,win,x,y,w,h,text,id)
  724.  UWORD          test;
  725.  struct Window *win;
  726.  UWORD          x,y,w,h;
  727.  UBYTE         *text;
  728.  UWORD          id;
  729. {
  730.  REGISTER UBYTE             f,b;
  731.  UWORD                      size;
  732.  REGISTER WORD              i,l;
  733.  BOOL                       toggle;
  734.  register struct RastPort  *rp;
  735.  register struct Gadget    *gad;
  736.  register struct IntuiText *it;
  737.  register struct Border    *b1,*b2,*b3,*b4;
  738.  register struct TextAttr  *ta;
  739.  UWORD                     *a1,*a2;
  740.  
  741.  if((test==1)||(test==2))
  742.   {
  743.    toggle=TRUE;
  744.    size=sizeof(struct Gadget)+4*(sizeof(struct Border))+24+sizeof(struct IntuiText)+sizeof(struct TextAttr);
  745.   }
  746.  else
  747.   {
  748.    toggle=FALSE;
  749.    size=sizeof(struct Gadget);
  750.   }
  751.  gad=AllocRemember(&win->UserData,size,MEMF_CLEAR|MEMF_PUBLIC);
  752.  if(gad!=NULL)
  753.   {
  754.    CopyMem(&StdGadget,gad,sizeof(struct Gadget));
  755.    if(toggle==TRUE)
  756.     {
  757.      rp=win->RPort;
  758.      if(SysBase->lib_Version>=36) { f=2; b=1; } else { f=1; b=2; }
  759.      gad->Activation |= TOGGLESELECT;
  760.      gad->Flags=GADGHIMAGE;
  761.      if(test==2) gad->Flags |= SELECTED;
  762.      b1=(ULONG)gad+(ULONG)sizeof(struct Gadget);
  763.      b2=(ULONG)b1+(ULONG)sizeof(struct Border);
  764.      b3=(ULONG)b2+(ULONG)sizeof(struct Border);
  765.      b4=(ULONG)b3+(ULONG)sizeof(struct Border);
  766.      a1=(ULONG)b4+(ULONG)sizeof(struct Border);
  767.      a2=(ULONG)a1+12L;
  768.      it=(ULONG)a2+12L;
  769.      ta=(ULONG)it+(ULONG)sizeof(struct IntuiText);
  770.      b1->LeftEdge=0;
  771.      b1->TopEdge=0;
  772.      b1->DrawMode=JAM1;
  773.      b1->Count=3;
  774.      CopyMem(b1,b2,sizeof(struct Border));
  775.      b1->FrontPen=f;
  776.      b1->BackPen=b;
  777.      b1->XY=a1;
  778.      b2->FrontPen=b;
  779.      b2->BackPen=f;
  780.      b2->XY=a2;
  781.      CopyMem(b1,b3,sizeof(struct Border));
  782.      CopyMem(b2,b4,sizeof(struct Border));
  783.      b3->FrontPen=b;
  784.      b3->BackPen=f;
  785.      b4->FrontPen=f;
  786.      b4->BackPen=b;
  787.      b1->NextBorder=b2;
  788.      b3->NextBorder=b4;
  789.      a1[0]=0; a1[1]=h; a1[2]=0; a1[3]=0; a1[4]=w; a1[5]=0;
  790.      a2[0]=1; a2[1]=h; a2[2]=w; a2[3]=h; a2[4]=w; a2[5]=1;
  791.      gad->GadgetRender=b1;
  792.      gad->SelectRender=b3;
  793.      it->FrontPen=f;
  794.      it->BackPen=b;
  795.      it->DrawMode=JAM1;
  796.      l=TextLength(rp,text,strlen(text));
  797.      i=(w-l)/2;
  798.      it->LeftEdge=i;
  799.      it->TopEdge=2;
  800.      it->ITextFont=ta;
  801.      it->IText=text;
  802.      gad->GadgetText=it;
  803.      ta->ta_Name=rp->Font->tf_Message.mn_Node.ln_Name;
  804.      ta->ta_YSize=rp->Font->tf_YSize;
  805.      ta->ta_Flags=rp->Font->tf_Flags;
  806.      ta->ta_Style=rp->AlgoStyle;
  807.     }
  808.    if(test==4) gad->Flags=GADGHNONE;
  809.    gad->LeftEdge=x;
  810.    gad->TopEdge=y;
  811.    gad->Width=w+1;
  812.    gad->Height=h+1;
  813.    gad->GadgetID=id;
  814.    AddGadget(win,gad,NULL);
  815.    OnGadget(gad,win,NULL);
  816.    if(test==0) DrawPTextBorder(win,x,y,w,h,text);
  817.    if(test==5) DrawMPTextBorder(win,x,y,w,h,text);
  818.   }
  819.  return(gad);
  820. }
  821.  
  822.  
  823. /* String- oder Integer-Gadget erstellen */
  824. UBYTE *CreateStrIntGadget(test,win,x,y,w,h,str,maxPos,id)
  825.  UWORD          test;
  826.  struct Window *win;
  827.  UWORD          x,y,w,h;
  828.  UBYTE         *str;
  829.  UWORD          maxPos,id;
  830. {
  831.  REGISTER LONG               i;
  832.  REGISTER UBYTE             *buffer,*undo;
  833.  register struct Gadget     *gad;
  834.  register struct StringInfo *si;
  835.  
  836.  buffer=NULL;
  837.  i=sizeof(struct Gadget)+sizeof(struct StringInfo)+(maxPos*2);
  838.  gad=AllocRemember(&win->UserData,i,MEMF_CLEAR|MEMF_PUBLIC);
  839.  if(gad!=NULL)
  840.   {
  841.    si=(ULONG)gad+(ULONG)sizeof(struct Gadget);
  842.    buffer=(ULONG)si+(ULONG)sizeof(struct StringInfo);
  843.    undo=(ULONG)buffer+(ULONG)maxPos;
  844.  
  845.    CopyMem(&StdStrGadget,gad,sizeof(struct Gadget));
  846.    if(test==1) gad->Activation += LONGINT;
  847.  
  848.    si->Buffer=buffer;
  849.    si->UndoBuffer=undo;
  850.    si->MaxChars=maxPos;
  851.    if(str!=NULL) si->BufferPos=strlen(str);
  852.    strcpy(buffer,str);
  853.  
  854.    if(h<=10)
  855.     {
  856.      gad->LeftEdge=x+3;
  857.      gad->Width=w-3;
  858.     }
  859.    else
  860.     {
  861.      gad->LeftEdge=x+4;
  862.      gad->Width=w-5;
  863.     }
  864.    gad->TopEdge=y+2;
  865.    gad->Height=h;
  866.    gad->GadgetID=id;
  867.    gad->SpecialInfo=si;
  868.  
  869.    AddGadget(win,gad,NULL);
  870.    OnGadget(gad,win,NULL);
  871.    if(h<=10)
  872.     {
  873.      DrawNBorder(win,x,y,w,h);
  874.     }
  875.    else
  876.     {
  877.      DrawNBorder(win,x+1,y+1,w-2,h-2);
  878.      DrawPBorder(win,x,y,w,h);
  879.     }
  880.   }
  881.  return(buffer);
  882. }
  883.  
  884.  
  885. /* Parallelen Prozeß erstellen */
  886. struct Task *CreateProcess(function,stack,name,pri)
  887.  VOID   (* function)();
  888.  ULONG  stack;
  889.  UBYTE *name;
  890.  BYTE   pri;
  891. {
  892.  register struct Process *proc;
  893.  register struct Segment *Segment;
  894.  
  895.  /* ----- Segment installieren ----------------------------------------- */
  896.  Segment=AllocMem(sizeof(struct Segment),MEMF_CLEAR|MEMF_PUBLIC);
  897.  if(Segment==NULL) return(NULL);
  898.  Segment->Length=sizeof(struct Segment);
  899.  Segment->Next=NULL;
  900.  Segment->OpCode=0x4EF9;                                          /* JMP */
  901.  Segment->Address=function;
  902.  Segment=(LONG)(&(Segment->Next)) >> 2;
  903.  
  904.  /* ----- Prozeß starten ----------------------------------------------- */
  905.  proc=CreateProc(name,pri,Segment,stack);
  906.  if(proc==NULL) return(NULL);
  907.  
  908.  /* ----- Weitere Installationen --------------------------------------- */
  909.  return((struct Task *)((ULONG)proc-(ULONG)sizeof(struct Task)));
  910. }
  911.  
  912.  
  913. /* Anzahl der freien Bytes von Janus-Speicher ermitteln */
  914. LONG AvailJanusMem(type)
  915.  UWORD type;
  916. {
  917.  REGISTER LONG                    bytes;
  918.  register struct DualPortedMemory *dpm;
  919.  
  920.  bytes=0;
  921.  Forbid();
  922.  JanusBase=OpenLibrary("janus.library",0L);
  923.  Permit();
  924.  if(JanusBase!=NULL)
  925.   {
  926.    dpm=MakeWordPtr(JanusBase->ParameterRAM);
  927.    if(type & MEMF_PARAMETER) bytes=dpm->ParameterRAM.Free;
  928.    if(type & MEMF_BUFFER) bytes+=dpm->BufferRAM.Free;
  929.   }
  930.  return(bytes);
  931. }
  932.  
  933.  
  934. /* Message beantworten */
  935. UWORD Received(port)
  936.  struct MsgPort *port;
  937. {
  938.  REGISTER UWORD           res;
  939.  register struct Message *msg;
  940.  
  941.  msg=GetMsg(port);
  942.  if(msg!=NULL)
  943.   {
  944.    res=msg->mn_Node.ln_Name;
  945.    FreeMem(msg,sizeof(struct Message));
  946.   }
  947.  else res=0;
  948.  return(res);
  949. }
  950.  
  951.  
  952. /* Informationen zum Programm */
  953. VOID InformationBox(scr,title,cp1,cp2,cp3,cp4,iconName,info)
  954.  struct Screen *scr;
  955.  UBYTE         *title;
  956.  UBYTE         *cp1,*cp2,*cp3,*cp4;
  957.  UBYTE         *iconName;
  958.  struct Info   *info;
  959. {
  960.  UBYTE                             TextBuffer[56],fk,ok;
  961.  BOOL                              ende,new;
  962.  ULONG                             a,b,c;
  963.  UWORD                             i,j;
  964.  REGISTER UBYTE                   *Prozessor;
  965.  REGISTER UBYTE                   *Coprozessor;
  966.  REGISTER UBYTE                   *Cache;
  967.  register struct RastPort         *InfoRastPort;
  968.  register struct IntuiMessage     *IMessage;
  969.  register struct Gadget           *gad;
  970.  register struct DualPortedMemory *dpm;
  971.  register struct Window           *InfoWindow;
  972.  register struct MenuStrip        *ms;
  973.  register struct DiskObject       *icon;
  974.  struct Image                      Image;
  975.  struct Image                     *im;
  976.  
  977.  icon=NULL;
  978.  if(IconBase && iconName) icon=GetDiskObject(iconName);
  979.  Forbid();
  980.  if(JanusBase==NULL) JanusBase=OpenLibrary("janus.library",0L);
  981.  Permit();
  982.  if(!(strncmp(cp1,"$VER: ",6))) cp1=(ULONG)cp1+(ULONG)6;
  983.  
  984.  InfoWindow=CreateWindow(scr,title,75,35,450,155+BorderHeight(),
  985.                          CLOSEWINDOW|INACTIVEWINDOW|VANILLAKEY|MENUPICK,
  986.                          ACTIVATE|WINDOWCLOSE|WINDOWDEPTH|WINDOWDRAG|GIMMEZEROZERO);
  987.  if(InfoWindow!=NULL)
  988.   {
  989.    InfoRastPort=InfoWindow->RPort;
  990.    SetFont(InfoRastPort,OpalFont);
  991.  
  992.    ms=NULL;
  993.    if(info!=NULL)
  994.     {
  995.      ms=BuildMenuStrip(InfoWindow,AUTOFRONTPEN,AUTOBACKPEN);
  996.      if(ms!=NULL)
  997.       {
  998.        AddMenu(ms,"Information",5,200);
  999.        AddItem(ms,"Copyright und Systeminfos",300,'Z',TRUE,TRUE);
  1000.        j=65;
  1001.        for(a=0;a<info->Items;a++)
  1002.         {
  1003.          if(info->InfoItem[a]->ShowItem!=0)
  1004.           {
  1005.            AddItem(ms,info->InfoItem[a]->Title,300,j,info->InfoItem[a]->EnableItem,TRUE);
  1006.            j++; if(j==(UWORD)'Q') j++; if(j==(UWORD)'Z') j=48;
  1007.           }
  1008.          else
  1009.            AddItem(ms,GetOpalLine(),300,0,FALSE,FALSE);
  1010.         }
  1011.        AddItem(ms,GetOpalLine(),300,0,FALSE,FALSE);
  1012.        AddItem(ms,"Information beenden",300,'Q',TRUE,TRUE);
  1013.        UseMenuStrip(ms);
  1014.       }
  1015.     }
  1016.    fk=ok=100;
  1017.    new=TRUE;
  1018.  
  1019.    ende=FALSE;
  1020.    do
  1021.     {
  1022.      if(new==TRUE)
  1023.       {
  1024.        SetAPen(InfoRastPort,0);
  1025.        RectFill(InfoRastPort,5,3,445,140);
  1026.        if(fk==100)
  1027.         {
  1028.          if(JanusBase)
  1029.           {
  1030.            dpm=JanusBase->ParameterRAM;
  1031.            dpm=MakeWordPtr(dpm);
  1032.            a=dpm->ParameterRAM.Free/1024;
  1033.            b=dpm->BufferRAM.Free/1024;
  1034.           }
  1035.          else
  1036.           {
  1037.            a=b=0;
  1038.           }
  1039.          Prozessor="Motorola 68000  16/32-Bit";
  1040.          Coprozessor="Nicht installiert";
  1041.          Cache="Nicht vorhanden";
  1042.          if(SysBase->AttnFlags & AFF_68010)
  1043.            Prozessor="Motorola 68010  16/32-Bit";
  1044.          if(SysBase->AttnFlags & AFF_68020)
  1045.            Prozessor="Motorola 68020  32-Bit";
  1046.          if(SysBase->AttnFlags & AFF_68030)
  1047.           {
  1048.            Prozessor="Motorola 68030  32-Bit";
  1049.            if(SysBase->lib_Version>=36)
  1050.             {
  1051.              c=CacheControl(0,0);
  1052.              Cache="Ausgeschaltet";
  1053.              if(c & CACRF_EnableD) Cache="Eingeschaltet";
  1054.              if((c & CACRF_EnableD)&&(c & CACRF_DBE)) Cache="Burst-Modus";
  1055.             }
  1056.            else
  1057.             {
  1058.              Cache="(Test erst ab DOS 2.0)";
  1059.             }
  1060.           }
  1061.          if(SysBase->AttnFlags & AFF_68881) Coprozessor="Motorola 68881";
  1062.          if(SysBase->AttnFlags & AFF_68882) Coprozessor="Motorola 68882";
  1063.          SetAPen(InfoRastPort,1);
  1064.          if(icon)
  1065.           {
  1066.            gad=&icon->do_Gadget;
  1067.            if(SysBase->lib_Version>=36)
  1068.             {
  1069.              DrawNBorder(InfoWindow,(417-gad->Width),25,gad->Width+6,gad->Height+6);
  1070.              DrawPBorder(InfoWindow,27,25,gad->Width+6,gad->Height+6);
  1071.             }
  1072.            Image.LeftEdge=0;
  1073.            Image.TopEdge=0;
  1074.            Image.NextImage=NULL;
  1075.            im=gad->GadgetRender;
  1076.            Image.Width=im->Width;
  1077.            Image.Height=im->Height;
  1078.            Image.Depth=im->Depth;
  1079.            Image.PlanePick=im->PlanePick;
  1080.            Image.PlaneOnOff=im->PlaneOnOff;
  1081.            Image.ImageData=im->ImageData;
  1082.            DrawImage(InfoRastPort,&Image,30,28);
  1083.            i=gad->SelectRender;
  1084.            if(i!=NULL)
  1085.             {
  1086.              Image.Width=im->Width;
  1087.              Image.Height=im->Height;
  1088.              Image.Depth=im->Depth;
  1089.              Image.PlanePick=im->PlanePick;
  1090.              Image.PlaneOnOff=im->PlaneOnOff;
  1091.              Image.ImageData=im->ImageData;
  1092.             }
  1093.            DrawImage(InfoRastPort,&Image,(420-gad->Width),28);
  1094.           }
  1095.          InfoText(InfoRastPort,cp1,10);
  1096.          InfoText(InfoRastPort,cp2,20);
  1097.          InfoText(InfoRastPort,cp3,30);
  1098.          InfoText(InfoRastPort,cp4,40);
  1099.          sprintf(&TextBuffer,"Parameter-Speicher: %2ld KB",a);
  1100.          InfoText(InfoRastPort,&TextBuffer,55);
  1101.          sprintf(&TextBuffer,"Buffer-Speicher: %2ld KB",b);
  1102.          InfoText(InfoRastPort,&TextBuffer,65);
  1103.          sprintf(&TextBuffer,"Chip-Speicher:    %4ld KB",
  1104.                               (AvailMem(MEMF_CHIP))/1024);
  1105.          InfoText(InfoRastPort,&TextBuffer,80);
  1106.          sprintf(&TextBuffer,"Fast-Speicher:    %4ld KB",
  1107.                               (AvailMem(MEMF_FAST))/1024);
  1108.          InfoText(InfoRastPort,&TextBuffer,90);
  1109.          sprintf(&TextBuffer,"Speicher gesamt:  %5ld KB",
  1110.                               (AvailMem(MEMF_ANY))/1024);
  1111.          InfoText(InfoRastPort,&TextBuffer,100);
  1112.          sprintf(&TextBuffer,"Hauptprozessor: %s",Prozessor);
  1113.          InfoText(InfoRastPort,&TextBuffer,115);
  1114.          sprintf(&TextBuffer,"Math. Copozessor: %s",Coprozessor);
  1115.          InfoText(InfoRastPort,&TextBuffer,125);
  1116.          sprintf(&TextBuffer,"Datencache: %s",Cache);
  1117.          InfoText(InfoRastPort,&TextBuffer,135);
  1118.         }
  1119.        else
  1120.         {
  1121.          j=10;
  1122.          SetAPen(InfoRastPort,1);
  1123.          for(i=0;i<14;i++)
  1124.           {
  1125.            if(info->InfoItem[fk]->Strings[i]!=0)
  1126.             {
  1127.              InfoText(InfoRastPort,info->InfoItem[fk]->Strings[i],j);
  1128.             }
  1129.            j+=10;
  1130.           }
  1131.         }
  1132.        new=FALSE;
  1133.       }
  1134.  
  1135.      WaitPort(InfoWindow->UserPort);
  1136.      IMessage=GetMsg(InfoWindow->UserPort);
  1137.      a=IMessage->Class;
  1138.      j=IMessage->Code;
  1139.      ReplyMsg(IMessage);
  1140.      switch(a)
  1141.       {
  1142.        case CLOSEWINDOW:
  1143.        case VANILLAKEY:
  1144.        case INACTIVEWINDOW:
  1145.          ende=TRUE;
  1146.         break;
  1147.        case MENUPICK:
  1148.          if(MENUNUM(j)==0)
  1149.           {
  1150.            i=ITEMNUM(j);
  1151.            if(i==0)
  1152.              ende=TRUE;
  1153.            else
  1154.             {
  1155.              if((i>1)&&(i<=info->Items+1))
  1156.                fk=(info->Items+1)-i;
  1157.              else if(i>info->Items+1)
  1158.                fk=100;
  1159.             }
  1160.            if(fk!=ok)
  1161.             {
  1162.              ok=fk;
  1163.              new=TRUE;
  1164.             }
  1165.           }
  1166.         break;
  1167.       }
  1168.     } while(ende==FALSE);
  1169.    if(ms) RemoveMenuStrip(ms);
  1170.    DeleteStdWindow(InfoWindow);
  1171.   }
  1172.  if(icon) FreeDiskObject(icon);
  1173. }
  1174.  
  1175.  
  1176. /* Text im Info-Fenster zentriert ausgeben */
  1177. VOID InfoText(rp,text,y)
  1178.  struct RastPort *rp;
  1179.  UBYTE           *text;
  1180.  WORD             y;
  1181. {
  1182.  REGISTER WORD x,length;
  1183.  
  1184.  length=strlen(text);
  1185.  x=(450-TextLength(rp,text,length))/2;
  1186.  Move(rp,x,y);
  1187.  Text(rp,text,length);
  1188. }
  1189.  
  1190.  
  1191. /* Cache-Steuerung bei Systemen mit 68020/030 und Kickstart 2.0 */
  1192. #asm
  1193.  ; Implementation von CacheControl
  1194.  ; (ab Kickstart 2.0)
  1195.    public _CacheControl
  1196. _CacheControl:
  1197.    move.l 4(sp),d0
  1198.    move.l 8(sp),d1
  1199.    move.l a6,-(sp)
  1200.    move.l $4,a6
  1201.    jsr -648(a6)
  1202.    move.l (sp)+,a6
  1203.    rts
  1204. #endasm
  1205.  
  1206.  
  1207. /* Information */
  1208. VOID LibraryInfo()
  1209. {
  1210.  InformationBox(NULL,
  1211.                 "ATUtilities Library - Information",
  1212.                 VERSION,
  1213.                 "Copyright (C) 1992-1994 by",
  1214.                 "Thomas Dreibholz",
  1215.                 "All rights reserved",
  1216.                 "AT:Icons/Library",NULL);
  1217. }
  1218.  
  1219.  
  1220. /* JInterrupt-Handler erstellen */
  1221. struct ExtSetupSig *CreatePrivateHandler(jint,size)
  1222.  UBYTE jint;
  1223.  UWORD size;
  1224. {
  1225.  REGISTER LONG                JanusSignal;
  1226.  REGISTER UWORD               offset;
  1227.  REGISTER UBYTE              *mem;
  1228.  register struct ExtSetupSig *ess;
  1229.  register struct SetupSig    *ss;
  1230.  
  1231.  ess=NULL;
  1232.  Forbid();
  1233.  if(JanusBase==NULL) JanusBase=OpenLibrary("janus.library",0L);
  1234.  Permit();
  1235.  if(JanusBase!=NULL)
  1236.   {
  1237.    JanusSignal=AllocSignal(-1L);
  1238.    if(JanusSignal>=0)
  1239.     {
  1240.      ess=AllocMem(sizeof(struct ExtSetupSig),MEMF_CLEAR|MEMF_PUBLIC);
  1241.      if(ess!=NULL)
  1242.       {
  1243.        ss=SetupJanusSig(jint,JanusSignal,0,0);
  1244.        if(ss!=NULL)
  1245.         {
  1246.          mem=AllocJanusMem(size+16,MEMF_BUFFER);
  1247.          if(mem!=NULL)
  1248.           {
  1249.            ess->System1=mem;
  1250.            ess->System2=size+16;
  1251.            offset=JanusMemToOffset(mem);
  1252.            offset=offset+(offset % 16);
  1253.            mem=JanusOffsetToMem(offset,MEMF_BUFFER|MEM_BYTEACCESS);
  1254.            ess->SetupSig=ss;
  1255.            ess->ByteAccess=MakeBytePtr(mem);
  1256.            ess->WordAccess=MakeWordPtr(mem);
  1257.            ess->Offset=offset;
  1258.            ess->JanusSignal=JanusSignal;
  1259.            ess->JanusSignalMask=(1L<<JanusSignal);
  1260.            SetParamOffset(jint,offset);
  1261.           }
  1262.          else
  1263.           {
  1264.            CleanupJanusSig(ss);
  1265.            FreeMem(ess,sizeof(struct ExtSetupSig));
  1266.            FreeSignal(JanusSignal);
  1267.            ErrorRequest(ERROR_SETUP);
  1268.           }
  1269.         }
  1270.        else
  1271.         {
  1272.          FreeMem(ess,sizeof(struct ExtSetupSig));
  1273.          ess=NULL;
  1274.          FreeSignal(JanusSignal);
  1275.          ErrorRequest(ERROR_SETUP);
  1276.         }
  1277.       }
  1278.      else
  1279.       {
  1280.        FreeSignal(JanusSignal);
  1281.        ErrorRequest(ERROR_JALLOC);
  1282.       }
  1283.     }
  1284.    else
  1285.     {
  1286.      ErrorRequest(ERROR_SIGNAL);
  1287.     }
  1288.   }
  1289.  else
  1290.   {
  1291.    ErrorRequest(ERROR_JANUS);
  1292.   }
  1293.  return(ess);
  1294. }
  1295.  
  1296.  
  1297. /* JInterrupt-Handler löschen */
  1298. VOID DeletePrivateHandler(ess)
  1299.  struct ExtSetupSig *ess;
  1300. {
  1301.  
  1302.  CleanupJanusSig(ess->SetupSig);
  1303.  FreeSignal(ess->JanusSignal);
  1304.  FreeJanusMem(ess->System1,ess->System2);
  1305.  FreeMem(ess,sizeof(struct ExtSetupSig));
  1306. }
  1307.  
  1308.  
  1309. /* DateStamp in normales Format umwandeln */
  1310. ULONG TageProMonat[]={00,31,28,31,
  1311.                       30,31,30,31,
  1312.                       31,30,31,30,
  1313.                       31};
  1314.  
  1315. VOID ConvertDateStamp(ds,new)
  1316.  struct DateStamp    *ds;
  1317.  struct NewDateStamp *new;
  1318. {
  1319.  REGISTER UWORD Tage,Jahr,Monat;
  1320.  
  1321.  Tage=ds->ds_Days;
  1322.  new->Hour=ds->ds_Minute/60;
  1323.  new->Minute=ds->ds_Minute%60;
  1324.  new->Second=ds->ds_Tick/TICKS_PER_SECOND;
  1325.  new->DayNum=Tage%7;
  1326.  Jahr=1978;
  1327.  while(Tage>365)
  1328.   {
  1329.    if((Jahr%4)==0) Tage-=366; else Tage-=365;
  1330.    Jahr++;
  1331.   }
  1332.  if((Tage==365) && !((Jahr%4)==0)) Tage-=365;
  1333.  if((Jahr%4)==0) TageProMonat[2]=29; else TageProMonat[2]=28;
  1334.  Monat=1;
  1335.  while(Tage>=TageProMonat[Monat])
  1336.   {
  1337.    Tage-=TageProMonat[Monat];
  1338.    Monat++;
  1339.   }
  1340.  Tage++;
  1341.  new->Year=Jahr;
  1342.  new->Month=Monat;
  1343.  new->Day=Tage;
  1344. }
  1345.  
  1346.  
  1347. /* App-Item erstellen */
  1348. struct AppManager *CreateAppItem(text)
  1349.  UBYTE *text;
  1350. {
  1351.  struct AppManager *app;
  1352.  struct MsgPort    *port;
  1353.  
  1354.  if(WorkbenchBase==NULL) return(NULL);
  1355.  app=AllocMem(sizeof(struct AppManager),MEMF_CLEAR|MEMF_PUBLIC);
  1356.  if(app!=NULL)
  1357.   {
  1358.    port=CreatePort(0L,0L);
  1359.    if(port!=NULL)
  1360.     {
  1361.      app->Port=port;
  1362.      app->AppItem=AddAppMenuItemA(0,0L,text,port,NULL);
  1363.      app->SignalMask=(1L<<port->mp_SigBit);
  1364.      if(app->AppItem==NULL)
  1365.       {
  1366.        DeletePort(port);
  1367.        FreeMem(app,sizeof(struct AppManager));
  1368.        return(NULL);
  1369.       }
  1370.     }
  1371.    else
  1372.     {
  1373.      FreeMem(app,sizeof(struct AppManager));
  1374.      return(NULL);
  1375.     }
  1376.   }
  1377.  else return(NULL);
  1378.  return(app);
  1379. }
  1380.  
  1381.  
  1382. /* App-Item löschen */
  1383. VOID DeleteAppItem(app)
  1384.  struct AppManager *app;
  1385. {
  1386.  RemoveAppMenuItem(app->AppItem);
  1387.  DeletePort(app->Port);
  1388.  FreeMem(app,sizeof(struct AppManager));
  1389. }
  1390.  
  1391.  
  1392. /* Task-Priorität ändern */
  1393. UBYTE ChangeTaskPri(pri)
  1394.  UBYTE pri;
  1395. {
  1396.  register struct Task *task;
  1397.  
  1398.  task=FindTask(NULL);
  1399.  return((UBYTE)SetTaskPri(task,pri));
  1400. }
  1401.  
  1402.  
  1403. /* Service erstellen */
  1404. struct ExtServiceData *CreatePublicService(appID,locID,flags)
  1405.  ULONG appID;
  1406.  UWORD locID;
  1407.  UWORD flags;
  1408. {
  1409.  LONG                   signal;
  1410.  WORD                   okay;
  1411.  UBYTE                 *mem;
  1412.  UWORD                 *jmem;
  1413.  struct ExtServiceData *esd;
  1414.  struct ServiceData    *serv;
  1415.  
  1416.  Forbid();
  1417.  if(JanusBase==NULL) JanusBase=OpenLibrary("janus.library",0L);
  1418.  Permit();
  1419.  if(JanusBase!=NULL)
  1420.   {
  1421.    mem=AllocCommMemory();
  1422.    if(mem==NULL)
  1423.     {
  1424.      ErrorRequest(ERROR_JALLOC);
  1425.      return(NULL);
  1426.     }
  1427.    esd=AllocMem(sizeof(struct ExtServiceData),MEMF_CLEAR|MEMF_PUBLIC);
  1428.    if(esd==NULL)
  1429.     {
  1430.      ErrorRequest(ERROR_ALLOC);
  1431.      FreeCommMemory();
  1432.      return(NULL);
  1433.     }
  1434.     signal=AllocSignal(-1);
  1435.     if(signal==-1)
  1436.      {
  1437.       ErrorRequest(ERROR_SIGNAL);
  1438.       FreeCommMemory();
  1439.       FreeMem(esd,sizeof(struct ExtServiceData));
  1440.       return(NULL);
  1441.      }
  1442.    okay=AddService(&serv,appID,locID,16,MEMF_BUFFER|MEM_WORDACCESS,signal,flags);
  1443.    if(okay==JSERV_OK)
  1444.     {
  1445.      esd->ServiceData=serv;
  1446.      esd->ByteAccess=MakeBytePtr(mem);
  1447.      esd->WordAccess=MakeWordPtr(mem);
  1448.      esd->Offset=JanusMemToOffset(mem);
  1449.      esd->JanusSignal=signal;
  1450.      esd->JanusSignalMask=(1L<<signal);
  1451.      esd->ServiceMem=serv->AmigaMemPtr;
  1452.  
  1453.      /* Das Offset des Service-Speichers wird gegen das Offset des
  1454.         CommMemory ausgetauscht - das Segment bleibt gleich wg. MEMF_BUFFER */
  1455.  
  1456.      esd->System=serv->PCMemPtr.PCOffset;
  1457.      serv->PCMemPtr.PCOffset=esd->Offset;
  1458.     }
  1459.    else
  1460.     {
  1461.      ErrorRequest(ERROR_ADDSERVICE);
  1462.      FreeCommMemory();
  1463.      FreeMem(esd,sizeof(struct ExtServiceData));
  1464.      FreeSignal(signal);
  1465.      return(NULL);
  1466.     }
  1467.    return(esd);
  1468.   }
  1469.  else
  1470.   {
  1471.    ErrorRequest(ERROR_JANUS);
  1472.    return(NULL);
  1473.   }
  1474. }
  1475.  
  1476.  
  1477. /* Service entfernen */
  1478. VOID DeletePublicService(esd)
  1479.  struct ExtServiceData *esd;
  1480. {
  1481.  esd->ServiceData->PCMemPtr.PCOffset=esd->System;
  1482.  DeleteService(esd->ServiceData);
  1483.  FreeSignal(esd->JanusSignal);
  1484.  FreeCommMemory();
  1485.  FreeMem(esd,sizeof(struct ExtServiceData));
  1486. }
  1487.  
  1488.  
  1489. /* Utility-Fenster aufrufen, ohne Requester bei Fehlern */
  1490. BOOL UtilityQuiet(name,type)
  1491.  UBYTE *name;
  1492.  UWORD  type;
  1493. {
  1494.  register struct MsgPort *port;
  1495.  register struct Message *msg;
  1496.  
  1497.  port=FindPort(name);
  1498.  if(port!=NULL)
  1499.   {
  1500.    msg=AllocMem(sizeof(struct Message),MEMF_CLEAR|MEMF_PUBLIC);
  1501.    if(msg!=NULL)
  1502.     {
  1503.      msg->mn_Node.ln_Type=NT_MESSAGE;
  1504.      msg->mn_Node.ln_Name=type;
  1505.      msg->mn_Node.mn_Length=sizeof(struct Message);
  1506.      PutMsg(port,msg);
  1507.      return(TRUE);
  1508.     }
  1509.   }
  1510.  return(FALSE);
  1511. }
  1512.  
  1513.  
  1514. /* Text in hervorgehobenen Rahmen "Mac-like" ausgeben */
  1515. VOID DrawMPTextBorder(win,x,y,w,h,tex)
  1516.  struct Window *win;
  1517.  UWORD          x,y,w,h;
  1518.  UBYTE         *tex;
  1519. {
  1520.  REGISTER UWORD l;
  1521.  UBYTE          s[262];
  1522.  
  1523.  if(w<25) w=25;
  1524.  l=strlen(tex);
  1525.  if(l>256) l=256;
  1526.  strncpy(&s,tex,l+1);
  1527.  MacFormat(win->RPort,&s,w-20);
  1528.  DrawPTextBorder(win,x,y,w,h,&s,1);
  1529. }
  1530.  
  1531.  
  1532. /* Text in gedrückten Rahmen "Mac-like" ausgeben */
  1533. VOID DrawMNTextBorder(win,x,y,w,h,tex)
  1534.  struct Window *win;
  1535.  UWORD          x,y,w,h;
  1536.  UBYTE         *tex;
  1537. {
  1538.  REGISTER UWORD l;
  1539.  UBYTE          s[262];
  1540.  
  1541.  if(w<25) w=25;
  1542.  l=strlen(tex);
  1543.  if(l>256) l=256;
  1544.  strncpy(&s,tex,l+1);
  1545.  MacFormat(win->RPort,&s,w-20);
  1546.  DrawNTextBorder(win,x,y,w,h,&s,1);
  1547. }
  1548.  
  1549.  
  1550. /* Proportionalgadget erstellen */
  1551. struct Gadget *CreatePropGadget(win,x,y,w,h,hp,vp,hb,vb,id)
  1552.  struct Window *win;
  1553.  UWORD          x,y,w,h;
  1554.  UWORD          hb,vb,hp,vp;
  1555.  UWORD          id;
  1556. {
  1557.  register struct Gadget   *gad;
  1558.  register struct PropInfo *pi;
  1559.  register struct Image    *im;
  1560.  
  1561.  gad=AllocRemember(&win->UserData,sizeof(struct Gadget)+
  1562.                                   sizeof(struct PropInfo)+
  1563.                                   sizeof(struct Image),MEMF_CLEAR|MEMF_PUBLIC);
  1564.  if(gad!=NULL)
  1565.   {
  1566.    pi=(ULONG)gad+(ULONG)sizeof(struct Gadget);
  1567.    im=(ULONG)pi+(ULONG)sizeof(struct PropInfo);
  1568.    gad->LeftEdge=x+1;
  1569.    gad->TopEdge=y+1;
  1570.    gad->Width=w-1;
  1571.    gad->Height=h-1;
  1572.    gad->Flags=GADGHCOMP;
  1573.    gad->Activation=RELVERIFY|GADGIMMEDIATE|FOLLOWMOUSE;
  1574.    gad->GadgetType=PROPGADGET;
  1575.    gad->GadgetRender=im;
  1576.    gad->GadgetID=id;
  1577.    gad->SpecialInfo=pi;
  1578.    pi->Flags=PROPBORDERLESS|AUTOKNOB;
  1579.    pi->HorizBody=hb;
  1580.    pi->VertBody=vb;
  1581.    pi->VertPot=vp;
  1582.    pi->HorizPot=hp;
  1583.    if(hb!=0) pi->Flags |= FREEHORIZ;
  1584.    if(vb!=0) pi->Flags |= FREEVERT;
  1585.    AddGadget(win,gad,-1);
  1586.    OnGadget(gad,win,NULL);
  1587.    DrawNBorder(win,x,y,w,h);
  1588.    return(gad);
  1589.   }
  1590.  return(NULL);
  1591. }
  1592.  
  1593.  
  1594. /* MenuStrip Grundstruktur erstellen */
  1595. struct MenuStrip *BuildMenuStrip(win,fp,bp)
  1596.  struct Window   *win;
  1597.  UWORD            fp,bp;
  1598. {
  1599.  register struct MenuStrip *ms;
  1600.  register struct RastPort  *rp;
  1601.  
  1602.  ms=AllocMem(sizeof(struct MenuStrip),MEMF_CLEAR|MEMF_PUBLIC);
  1603.  if(ms!=NULL)
  1604.   {
  1605.    ms->Window=win;
  1606.    rp=win->RPort;
  1607.    ms->TextAttr.ta_Name=rp->Font->tf_Message.mn_Node.ln_Name;
  1608.    ms->TextAttr.ta_YSize=rp->Font->tf_YSize;
  1609.    ms->TextAttr.ta_Flags=rp->Font->tf_Flags;
  1610.    ms->TextAttr.ta_Style=rp->AlgoStyle;
  1611.    ms->FrontPen=fp;
  1612.    ms->BackPen=bp;
  1613.   }
  1614.  return(ms);
  1615. }
  1616.  
  1617.  
  1618. /* Neues Menü erstellen */
  1619. struct Menu *AddMenu(ms,name,x,w)
  1620.  struct MenuStrip *ms;
  1621.  UBYTE            *name;
  1622.  UWORD             x,w;
  1623. {
  1624.  register struct Menu *me;
  1625.  
  1626.  me=AllocRemember(&ms->Remember,sizeof(struct Menu),MEMF_CLEAR|MEMF_PUBLIC);
  1627.  if(me!=NULL)
  1628.   {
  1629.    me->LeftEdge=x;
  1630.    me->TopEdge=0;
  1631.    me->Width=w;
  1632.    me->Height=10;
  1633.    me->Flags=MENUENABLED;
  1634.    me->MenuName=name;
  1635.    me->NextMenu=ms->LastMenu;
  1636.    ms->LastMenu=me;
  1637.    ms->LastItem=NULL;
  1638.    ms->LastSubItem=NULL;
  1639.   }
  1640.  return(me);
  1641. }
  1642.  
  1643.  
  1644. /* Neues Item erstellen */
  1645. struct MenuItem *AddItem(ms,name,w,cmd,enabled,highcomp)
  1646.  struct MenuStrip *ms;
  1647.  UBYTE            *name;
  1648.  UWORD             w;
  1649.  UBYTE             cmd;
  1650.  BOOL              enabled,highcomp;
  1651. {
  1652.  register struct Menu      *me;
  1653.  register struct MenuItem  *mi;
  1654.  register struct IntuiText *it;
  1655.  
  1656.  me=ms->LastMenu;
  1657.  if(me!=NULL)
  1658.   {
  1659.    mi=AllocRemember(&ms->Remember,sizeof(struct MenuItem)+sizeof(struct IntuiText),MEMF_CLEAR|MEMF_PUBLIC);
  1660.    if(mi!=NULL)
  1661.     {
  1662.      it=(ULONG)mi+(ULONG)sizeof(struct MenuItem);
  1663.  
  1664.      if(ms->LastItem!=NULL)
  1665.        mi->TopEdge=ms->LastItem->TopEdge+10;
  1666.      else
  1667.        mi->TopEdge=0;
  1668.      mi->LeftEdge=0;
  1669.      mi->Width=w;
  1670.      mi->Height=10;
  1671.      mi->Flags=ITEMTEXT;
  1672.      if(enabled) mi->Flags |= ITEMENABLED;
  1673.      if(highcomp) mi->Flags |= HIGHCOMP; else mi->Flags |= HIGHNONE;
  1674.      if(cmd!=0)
  1675.       {
  1676.        mi->Flags |= COMMSEQ;
  1677.        mi->Command=cmd;
  1678.       }
  1679.      mi->ItemFill=it;
  1680.      it->LeftEdge=AUTOLEFTEDGE;
  1681.      it->TopEdge=1;
  1682.      it->DrawMode=JAM1;
  1683.      it->FrontPen=ms->FrontPen;
  1684.      it->BackPen=ms->BackPen;
  1685.      it->ITextFont=&ms->TextAttr;
  1686.      it->IText=name;
  1687.      mi->NextItem=ms->LastItem;
  1688.      ms->LastItem=mi;
  1689.      ms->LastSubItem=NULL;
  1690.      me->FirstItem=mi;
  1691.     }
  1692.   }
  1693.  return(mi);
  1694. }
  1695.  
  1696.  
  1697. /* Neues Sub-Item erstellen */
  1698. struct MenuItem *AddSubItem(ms,name,w,cmd,enabled,highcomp)
  1699.  struct MenuStrip *ms;
  1700.  UBYTE            *name;
  1701.  UWORD             w;
  1702.  UBYTE             cmd;
  1703.  BOOL              enabled,highcomp;
  1704. {
  1705.  register struct MenuItem  *mi,*sub;
  1706.  register struct IntuiText *it;
  1707.  
  1708.  sub=ms->LastItem;
  1709.  if(sub!=NULL)
  1710.   {
  1711.    mi=AllocRemember(&ms->Remember,sizeof(struct MenuItem)+sizeof(struct IntuiText),MEMF_CLEAR|MEMF_PUBLIC);
  1712.    if(mi!=NULL)
  1713.     {
  1714.      it=(ULONG)mi+(ULONG)sizeof(struct MenuItem);
  1715.  
  1716.      if(ms->LastItem!=NULL)
  1717.        mi->TopEdge=ms->LastItem->TopEdge+10;
  1718.      else
  1719.        mi->TopEdge=0;
  1720.      mi->LeftEdge=0;
  1721.      mi->Width=w;
  1722.      mi->Height=10;
  1723.      mi->Flags=ITEMTEXT;
  1724.      if(enabled) mi->Flags |= ITEMENABLED;
  1725.      if(highcomp) mi->Flags |= HIGHCOMP; else mi->Flags |= HIGHNONE;
  1726.      if(cmd!=0)
  1727.       {
  1728.        mi->Flags |= COMMSEQ;
  1729.        mi->Command=cmd;
  1730.       }
  1731.      mi->ItemFill=it;
  1732.      it->LeftEdge=AUTOLEFTEDGE;
  1733.      it->TopEdge=1;
  1734.      it->DrawMode=JAM1;
  1735.      it->FrontPen=ms->FrontPen;
  1736.      it->BackPen=ms->BackPen;
  1737.      it->ITextFont=&ms->TextAttr;
  1738.      it->IText=name;
  1739.      mi->NextItem=ms->LastSubItem;
  1740.      ms->LastSubItem=mi;
  1741.      sub->SubItem=mi;
  1742.     }
  1743.   }
  1744.  return(mi);
  1745. }
  1746.  
  1747.  
  1748. /* Menü-Strip zu Window hinzufügen */
  1749. VOID UseMenuStrip(ms)
  1750.  struct MenuStrip *ms;
  1751. {
  1752.  
  1753.  if(ms->LastMenu!=NULL) SetMenuStrip(ms->Window,ms->LastMenu);
  1754. }
  1755.  
  1756.  
  1757. /* Menü-Strip entfernen */
  1758. VOID RemoveMenuStrip(ms,bool)
  1759.  struct MenuStrip *ms;
  1760.  BOOL              bool;
  1761. {
  1762.  ClearMenuStrip(ms->Window);
  1763.  if(ms->Remember!=NULL) FreeRemember(&ms->Remember,TRUE);
  1764.  ms->Remember=NULL;
  1765.  ms->LastMenu=NULL;
  1766.  ms->LastItem=NULL;
  1767.  ms->LastSubItem=NULL;
  1768.  if(bool==TRUE) FreeMem(ms,sizeof(struct MenuStrip));
  1769. }
  1770.  
  1771.  
  1772. /* 300 Pixel-Trennlinie für Opal-Font */
  1773. UBYTE *GetOpalLine()
  1774. {
  1775.  return((UBYTE *)"·········································································");
  1776. }
  1777.  
  1778.  
  1779. /* 450 Pixel-Trennlinie für Opal-Font */
  1780. UBYTE *GetOpalLine450()
  1781. {
  1782.  return((UBYTE *)"···············································································································");
  1783. }
  1784.  
  1785.  
  1786. /* String in Mac-like-Format umwandeln */
  1787. VOID MacFormat(rp,tex,x)
  1788.  struct RastPort *rp;
  1789.  UBYTE           *tex;
  1790.  UWORD            x;
  1791. {
  1792.  REGISTER UWORD i,j,k,l;
  1793.  
  1794.  k=strlen(tex);
  1795.  l=TextLength(rp,tex,k);
  1796.  if(l>x)
  1797.   {
  1798.    i=0;
  1799.    j=TextLength(rp,"...",3);
  1800.    l=j;
  1801.    do
  1802.     {
  1803.      j+=TextLength(rp,&tex[i],1L);
  1804.      i++;
  1805.     } while(j<x);
  1806.    tex[i]=0x00;
  1807.    for(j=i-1;j>0;j--)
  1808.     {
  1809.      if(tex[j]==' ') tex[j]=0x00; else break;
  1810.     }
  1811.    if(tex[0]!=0x00) strcat(tex,"...");
  1812.   }
  1813. }
  1814.  
  1815.  
  1816. struct BMHD
  1817. {
  1818.  UWORD Width,Height;
  1819.  UWORD LeftEdge,TopEdge;
  1820.  UBYTE BitPlanes;
  1821.  UBYTE Masking;
  1822.  UBYTE Compression;
  1823.  UBYTE pad;
  1824.  UWORD TransCol;
  1825.  UBYTE XAspace,YAspect;
  1826.  UWORD ScreenWidth,ScreenHeight;
  1827. };
  1828.  
  1829. struct ColReg
  1830. {
  1831.  UBYTE Red;
  1832.  UBYTE Green;
  1833.  UBYTE Blue;
  1834. };
  1835.  
  1836. struct CAMG
  1837. {
  1838.  UWORD pad;
  1839.  UWORD ViewModes;
  1840. };
  1841.  
  1842. struct CRNG
  1843. {
  1844.  UWORD  pad;
  1845.  UWORD  Rate;
  1846.  UWORD  Active;
  1847.  UBYTE  Low,High;
  1848. };
  1849.  
  1850. struct RInfo
  1851. {
  1852.  UBYTE *Memory;
  1853.  ULONG  Pos;
  1854.  ULONG  Max;
  1855. };
  1856.  
  1857. ULONG Lesen(ri,m,l)
  1858.  struct RInfo *ri;
  1859.  UBYTE        *m;
  1860.  ULONG         l;
  1861. {
  1862.  if((ri->Pos+l)>ri->Max) l=(ri->Max-ri->Pos);
  1863.  CopyMem(&ri->Memory[ri->Pos],m,l);
  1864.  ri->Pos+=l;
  1865.  return(l);
  1866. }
  1867.  
  1868. VOID Jump(ri,l)
  1869.  struct RInfo *ri;
  1870.  ULONG         l;
  1871. {
  1872.  if((ri->Pos+l)>ri->Max) l=(ri->Max-ri->Pos);
  1873.  ri->Pos+=l;
  1874. }
  1875.  
  1876. UBYTE ColorCount[]={1,2,4,8,16,32,32,32,32};
  1877.  
  1878.  
  1879. /* ILBM-Bild anzeigen */
  1880. BOOL DisplayPicture(mem,len)
  1881.  UBYTE *mem;
  1882.  LONG   len;
  1883. {
  1884.  struct Screen          *scr;
  1885.  struct NewScreen        ns;
  1886.  UBYTE                   Buffer[300];
  1887.  ULONG                   l;
  1888.  BOOL                    BMHDFlag,BODYFlag,CMAPFlag,CAMGFlag,CRNGFlag,FoundChunk;
  1889.  ULONG                   ChunkLen;
  1890.  UWORD                   y,ByteCount,i;
  1891.  UWORD                   iRowBytes,scrRowBytes;
  1892.  UWORD                   scrWidth,scrHeight,iWidth,iHeight;
  1893.  UBYTE                   iDepth,b;
  1894.  ULONG                   dest;
  1895.  struct RInfo           *fh;
  1896.  struct RInfo            ri;
  1897.  struct BMHD             bmhd;
  1898.  struct CAMG             camg;
  1899.  struct CRNG             crng;
  1900.  struct ColReg           Farben[32];
  1901.  UWORD                   AnzFarben;
  1902.  struct ColReg           Farbe;
  1903.  
  1904.  ri.Memory=mem;
  1905.  ri.Pos=0;
  1906.  ri.Max=len;
  1907.  fh=&ri;
  1908.  
  1909.  Lesen(fh,&Buffer,12);
  1910.  
  1911.  if(strncmp(&Buffer[0],"FORM",4)!=0)
  1912.   { InfoRequest("Bild hat kein IFF-Format!");
  1913.      return(FALSE); }
  1914.  if(strncmp(&Buffer[8],"ILBM",4)!=0)
  1915.   { InfoRequest("Bild hat kein ILBM-Format!");
  1916.    return(FALSE); }
  1917.  
  1918.  BMHDFlag=FALSE;
  1919.  BODYFlag=FALSE;
  1920.  CAMGFlag=FALSE;
  1921.  CMAPFlag=FALSE;
  1922.  CRNGFlag=FALSE;
  1923.  
  1924. Loop:
  1925.  FoundChunk=FALSE;
  1926.  l=Lesen(fh,&Buffer,8);
  1927.  if((l==0)||((BMHDFlag==TRUE)&&(BODYFlag==TRUE)&&(CMAPFlag==TRUE)))
  1928.   {
  1929.    if((BMHDFlag==TRUE)&&(BODYFlag==TRUE)&&(CMAPFlag==TRUE))
  1930.     {
  1931.      ShowTitle(scr,FALSE);
  1932.  
  1933.      if(CRNGFlag==TRUE)
  1934.       {
  1935.        if(crng.Active!=0)
  1936.         {
  1937.          y=crng.Rate/273;
  1938.          if(y==0) y=1;
  1939.          y=50/y;
  1940.          while((MouseButton())==0)
  1941.           {
  1942.            Farbe.Red=Farben[crng.Low].Red;
  1943.            Farbe.Green=Farben[crng.Low].Green;
  1944.            Farbe.Blue=Farben[crng.Low].Blue;
  1945.            for(i=crng.Low;i<crng.High;i++)
  1946.             {
  1947.              Farben[i].Red=Farben[i+1].Red;
  1948.              Farben[i].Green=Farben[i+1].Green;
  1949.              Farben[i].Blue=Farben[i+1].Blue;
  1950.             }
  1951.            Farben[crng.High].Red=Farbe.Red;
  1952.            Farben[crng.High].Green=Farbe.Green;
  1953.            Farben[crng.High].Blue=Farbe.Blue;
  1954.            for(i=crng.Low;i<crng.High;i++)
  1955.             {
  1956.              SetRGB4(&scr->ViewPort,i,Farben[i].Red,
  1957.                                       Farben[i].Green,
  1958.                                       Farben[i].Blue);
  1959.             }
  1960.            Delay(y);
  1961.           }
  1962.         }
  1963.       }
  1964.      else
  1965.       {
  1966.        while((MouseButton())==0)
  1967.          Delay(5);
  1968.       }
  1969.  
  1970.      CloseScreen(scr);
  1971.      return(TRUE);
  1972.     }
  1973.    else
  1974.     {
  1975.      if((BMHDFlag==TRUE)||(BODYFlag==TRUE)||(CMAPFlag==TRUE))
  1976.       {
  1977.        if(BMHDFlag==FALSE) InfoRequest("Bild hat keinen BMHD-Chunk!");
  1978.        else if(BODYFlag==FALSE) InfoRequest("Bild hat keinen BODY-Chunk!");
  1979.        else if(CMAPFlag==FALSE) InfoRequest("Bild hat keinen CMAP-Chunk!");
  1980.        if(scr!=NULL) CloseScreen(scr);
  1981.        return(FALSE);
  1982.       }
  1983.     }
  1984.   }
  1985.  ChunkLen=Buffer[4]*16777216+Buffer[5]*65536+Buffer[6]*256+Buffer[7];
  1986.  if(strncmp(&Buffer,"BMHD",4)==0)
  1987.   {
  1988.      if(sizeof(struct BMHD)<ChunkLen) InfoRequest("BMHD!");
  1989.    Lesen(fh,&bmhd,ChunkLen);
  1990.    if(bmhd.Compression>1)
  1991.     {
  1992.      InfoRequest("Unbekannte Kompressionsmethode!");
  1993.      return(FALSE);
  1994.     }
  1995.    scrWidth=bmhd.ScreenWidth;
  1996.    scrHeight=bmhd.ScreenHeight;
  1997.    iDepth=bmhd.BitPlanes;
  1998.    iWidth=bmhd.Width;
  1999.    iHeight=bmhd.Height;
  2000.    iRowBytes=iWidth/8;
  2001.    scrRowBytes=scrWidth/8;
  2002.    ns.LeftEdge   = 0;
  2003.    ns.TopEdge    = 0;
  2004.    ns.Width      = scrWidth;
  2005.    ns.Height     = scrHeight;
  2006.    ns.Depth      = iDepth;
  2007.    ns.DetailPen  = 1;
  2008.    ns.BlockPen   = 0;
  2009.    if(CAMGFlag==TRUE)
  2010.     {
  2011.      ns.ViewModes = camg.ViewModes;
  2012.     }
  2013.    else
  2014.     {
  2015.      ns.ViewModes  = 0;
  2016.      if(ns.Width>320) ns.ViewModes |= HIRES;
  2017.      if(ns.Height>256) ns.ViewModes |= LACE;
  2018.     }
  2019.    ns.Type         = CUSTOMSCREEN;
  2020.    ns.Font         = NULL;
  2021.    ns.DefaultTitle = "Ende mit Mausklick";
  2022.    ns.Gadgets      = NULL;
  2023.    ns.CustomBitMap = NULL;
  2024.    scr=OpenScreen(&ns);
  2025.    if(scr==NULL)
  2026.     {
  2027.      InfoRequest("Kann Screen nicht öffnen!");
  2028.      return(FALSE);
  2029.     }
  2030.    BMHDFlag=TRUE;
  2031.    FoundChunk=TRUE;
  2032.   }
  2033.  if(strncmp(&Buffer,"CMAP",4)==0)
  2034.   {
  2035.    if(BMHDFlag==FALSE)
  2036.     { InfoRequest("BMHD-Chunk muß vor CMAP-Chunk stehen!");
  2037.       return(FALSE); }
  2038.  
  2039.    AnzFarben=ColorCount[bmhd.BitPlanes];
  2040.    for(i=0;i<AnzFarben;i++)
  2041.     {
  2042.      if(ChunkLen>=3)
  2043.       {
  2044.        Lesen(fh,&Farbe,3);
  2045.        ChunkLen-=3;
  2046.       }
  2047.      else
  2048.       {
  2049.        Farbe.Red=0;
  2050.        Farbe.Green=0;
  2051.        Farbe.Blue=0;
  2052.       }
  2053.      Farben[i].Red=Farbe.Red>>4;
  2054.      Farben[i].Green=Farbe.Green>>4;
  2055.      Farben[i].Blue=Farbe.Blue>>4;
  2056.      SetRGB4(&scr->ViewPort,i,Farben[i].Red,
  2057.                               Farben[i].Green,
  2058.                               Farben[i].Blue);
  2059.     }
  2060.    CMAPFlag   = TRUE;
  2061.    FoundChunk = TRUE;
  2062.   }
  2063.  if(strncmp(&Buffer,"BODY",4)==0)
  2064.   {
  2065.    if(BMHDFlag==FALSE)
  2066.     { InfoRequest("BMHD-Chunk muß vor BODY-Chunk stehen!");
  2067.       return(FALSE); }
  2068.  
  2069.    if(bmhd.Compression==0)
  2070.     {
  2071.      for(y=0;y<iHeight;y++)
  2072.       {
  2073.        for(b=0;b<iDepth;b++)
  2074.         {
  2075.          dest=(ULONG)(scr->RastPort.BitMap->Planes[b])+(ULONG)y*(ULONG)scrRowBytes;
  2076.          Lesen(fh,dest,iRowBytes);
  2077.         }
  2078.       }
  2079.     }
  2080.    else
  2081.     {
  2082.      for(y=0;y<iHeight;y++)
  2083.       {
  2084.        for(b=0;b<iDepth;b++)
  2085.         {
  2086.          dest=(ULONG)(scr->RastPort.BitMap->Planes[b])+(ULONG)y*(ULONG)scrRowBytes;
  2087.          ByteCount=0;
  2088.  
  2089.          while(ByteCount<iRowBytes)
  2090.           {
  2091.            Lesen(fh,&Buffer[0],1);
  2092.            if(Buffer[0]<128)
  2093.             {
  2094.              Lesen(fh,(ULONG)dest+(ULONG)ByteCount,Buffer[0]+1);
  2095.              ByteCount+=Buffer[0]+1;
  2096.             }
  2097.            else if(Buffer[0]>128)
  2098.             {
  2099.              Lesen(fh,&Buffer[1],1);
  2100.              for(i=ByteCount;i<=(ByteCount+(257-Buffer[0]));i++)
  2101.                { *((UBYTE *)dest+(UBYTE *)i)=Buffer[1]; }
  2102.              ByteCount += 257-Buffer[0];
  2103.             }
  2104.           }
  2105.         }
  2106.       }
  2107.     }
  2108.    BODYFlag   = TRUE;
  2109.    FoundChunk = TRUE;
  2110.   }
  2111.  if(strncmp(&Buffer,"CAMG",4)==0)
  2112.   {
  2113.    Lesen(fh,&camg,ChunkLen);
  2114.    if(BMHDFlag==FALSE)
  2115.     { InfoRequest("BMHD-Chunk muß vor CAMG-Chunk stehen!");
  2116.       return(FALSE); }
  2117.    scr->ViewPort.Modes=camg.ViewModes;
  2118.    RemakeDisplay();
  2119.    CAMGFlag   = TRUE;
  2120.    FoundChunk = TRUE;
  2121.   }
  2122.  if(strncmp(&Buffer,"CRNG",4)==0)
  2123.   {
  2124.    if(CRNGFlag==FALSE)
  2125.     {
  2126.      Lesen(fh,&crng,ChunkLen);
  2127.      CRNGFlag   = TRUE;
  2128.      FoundChunk = TRUE;
  2129.     }
  2130.   }
  2131.  if(FoundChunk==FALSE)
  2132.   {
  2133.    Jump(fh,ChunkLen);
  2134.    if((ChunkLen & 1)) Jump(fh,1);
  2135.   }
  2136.  goto Loop;
  2137. }
  2138.  
  2139.  
  2140. /* IFF-Bild laden und anzeigen */
  2141. BOOL ShowPicture(name)
  2142.  UBYTE *name;
  2143. {
  2144.  REGISTER UBYTE             *mem;
  2145.  REGISTER ULONG              size;
  2146.  register struct FileHandle *fh;
  2147.  
  2148.  fh=Open(name,MODE_OLDFILE);
  2149.  if(fh!=NULL)
  2150.   {
  2151.    Seek(fh,0,OFFSET_END);
  2152.    size=Seek(fh,0,OFFSET_BEGINNING);
  2153.    mem=AllocMem(size,MEMF_CLEAR|MEMF_PUBLIC);
  2154.    if(mem!=NULL)
  2155.     {
  2156.      Read(fh,mem,size);
  2157.      DisplayPicture(mem,size);
  2158.      FreeMem(mem,size);
  2159.     }
  2160.    else ErrorRequest(ERROR_ALLOC);
  2161.   }
  2162.  else return(FALSE);
  2163.  return(TRUE);
  2164. }
  2165.  
  2166.  
  2167. /* Testen, ob Maustaste gedrückt ist */
  2168. #asm
  2169.    public _MouseButton
  2170. _MouseButton:
  2171.    btst #6,$bfe001
  2172.    bne 1$
  2173.    move.l #1,d0
  2174.    rts
  2175. 1$:
  2176.    clr.l d0
  2177.    rts
  2178. #endasm
  2179.  
  2180.  
  2181. /* Online-Hilfe aufrufen */
  2182. VOID Help(name,seite)
  2183.  UBYTE *name;
  2184.  UWORD  seite;
  2185. {
  2186.  REGISTER BOOL bool;
  2187.  UBYTE         str[130];
  2188.  
  2189.  sprintf(&str,"run >NIL: cc:prgs/atkey/hlp %s %ld",name,seite);
  2190.  bool=Execute(&str,0L,0L);
  2191.  if(bool==FALSE)
  2192.   {
  2193.    MultiRequest("Kann Hilfe-System nicht starten:",
  2194.                 "AT:Online Help","Okay",NULL);
  2195.   }
  2196. }
  2197.  
  2198. UWORD BorderHeight()
  2199. {
  2200.  register struct Screen *scr;
  2201.  
  2202.  scr=OpenWorkBench();
  2203.  return(scr->WBorTop+scr->Font->ta_YSize+1);
  2204. }
  2205.  
  2206.